#include "qxtglobalshortcut_p.h"
/****************************************************************************
** Copyright (c) 2006 - 2011, the LibQxt project.
** See the Qxt AUTHORS file for a list of authors and copyright holders.
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions are met:
**     * Redistributions of source code must retain the above copyright
**       notice, this list of conditions and the following disclaimer.
**     * Redistributions in binary form must reproduce the above copyright
**       notice, this list of conditions and the following disclaimer in the
**       documentation and/or other materials provided with the distribution.
**     * Neither the name of the LibQxt project nor the
**       names of its contributors may be used to endorse or promote products
**       derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
** DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**
** <http://libqxt.org>  <foundation@libqxt.org>
*****************************************************************************/

#include <QVector>
#include <QEvent>
#include <QCursor>
#include <QVariant>
#include <X11/Xlib.h>
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
#   include <QX11Info>
#else
#   include <QApplication>
#   include <qpa/qplatformnativeinterface.h>
#   include <xcb/xcb.h>
#endif

namespace {

const QVector<quint32> maskModifiers = QVector<quint32>()
                                       << 0 << Mod2Mask << LockMask << ( Mod2Mask | LockMask );

typedef int ( *X11ErrorHandler ) ( Display* display, XErrorEvent* event );

class QxtX11ErrorHandler
{
public:
    static bool error;

    static int qxtX11ErrorHandler ( Display* display, XErrorEvent* event ) {
        Q_UNUSED ( display );
        switch ( event->error_code ) {
            case BadAccess:
            case BadValue:
            case BadWindow:
                if ( event->request_code == 33 /* X_GrabKey */ ||
                     event->request_code == 34 /* X_UngrabKey */ ) {
                    error = true;
                    //TODO:
                    //char errstr[256];
                    //XGetErrorText(dpy, err->error_code, errstr, 256);
                }
        }
        return 0;
    }

    QxtX11ErrorHandler() {
        error = false;
        m_previousErrorHandler = XSetErrorHandler ( qxtX11ErrorHandler );
    }

    ~QxtX11ErrorHandler() {
        XSetErrorHandler ( m_previousErrorHandler );
    }

private:
    X11ErrorHandler m_previousErrorHandler;
};

bool QxtX11ErrorHandler::error = false;

class QxtX11Data
{
public:
    QxtX11Data() {
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
        m_display = QX11Info::display();
#else
        QPlatformNativeInterface* native = qApp->platformNativeInterface();
        void* display = native->nativeResourceForScreen ( QByteArray ( "display" ),
                                                          QGuiApplication::primaryScreen() );
        m_display = reinterpret_cast<Display*> ( display );
#endif
    }

    bool isValid() {
        return m_display != 0;
    }

    Display* display() {
        Q_ASSERT ( isValid() );
        return m_display;
    }

    Window rootWindow() {
        return DefaultRootWindow ( display() );
    }

    bool grabKey ( quint32 keycode, quint32 modifiers, Window window ) {
        QxtX11ErrorHandler errorHandler;

        for ( int i = 0; !errorHandler.error && i < maskModifiers.size(); ++i ) {
            XGrabKey ( display(), keycode, modifiers | maskModifiers[i], window, True,
                       GrabModeAsync, GrabModeAsync );
        }

        if ( errorHandler.error ) {
            ungrabKey ( keycode, modifiers, window );
            return false;
        }

        return true;
    }

    bool ungrabKey ( quint32 keycode, quint32 modifiers, Window window ) {
        QxtX11ErrorHandler errorHandler;

        foreach ( quint32 maskMods, maskModifiers ) {
            XUngrabKey ( display(), keycode, modifiers | maskMods, window );
        }

        return !errorHandler.error;
    }

private:
    Display* m_display;
};

} // namespace

#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
bool QxtGlobalShortcutPrivate::eventFilter ( void* message )
{
    XEvent* event = static_cast<XEvent*> ( message );
    if ( event->type == KeyPress )
    {
        XKeyEvent* key = reinterpret_cast<XKeyEvent*> ( event );
        unsigned int keycode = key->keycode;
        unsigned int keystate = key->state;
#else
bool QxtGlobalShortcutPrivate::nativeEventFilter ( const QByteArray& eventType,
                                                   void* message, long* result )
{
    Q_UNUSED ( result );

    xcb_key_press_event_t* kev = 0;
    if ( eventType == "xcb_generic_event_t" )
    {
        xcb_generic_event_t* ev = static_cast<xcb_generic_event_t*> ( message );
        if ( ( ev->response_type & 127 ) == XCB_KEY_PRESS )
            kev = static_cast<xcb_key_press_event_t*> ( message );
    }

    if ( kev != 0 )
    {
        unsigned int keycode = kev->detail;
        unsigned int keystate = 0;
        if ( kev->state & XCB_MOD_MASK_1 )
            keystate |= Mod1Mask;
        if ( kev->state & XCB_MOD_MASK_CONTROL )
            keystate |= ControlMask;
        if ( kev->state & XCB_MOD_MASK_4 )
            keystate |= Mod4Mask;
        if ( kev->state & XCB_MOD_MASK_SHIFT )
            keystate |= ShiftMask;
#endif
        activateShortcut ( keycode,
                           // Mod1Mask == Alt, Mod4Mask == Meta
                           keystate & ( ShiftMask | ControlMask | Mod1Mask | Mod4Mask ) );
    }
#if QT_VERSION < QT_VERSION_CHECK(5,0,0)
    return prevEventFilter ? prevEventFilter ( message ) : false;
#else
    return false;
#endif
}

quint32 QxtGlobalShortcutPrivate::nativeModifiers ( Qt::KeyboardModifiers modifiers )
{
    // ShiftMask, LockMask, ControlMask, Mod1Mask, Mod2Mask, Mod3Mask, Mod4Mask, and Mod5Mask
    quint32 native = 0;
    if ( modifiers & Qt::ShiftModifier )
        native |= ShiftMask;
    if ( modifiers & Qt::ControlModifier )
        native |= ControlMask;
    if ( modifiers & Qt::AltModifier )
        native |= Mod1Mask;
    if ( modifiers & Qt::MetaModifier )
        native |= Mod4Mask;

    // TODO: resolve these?
    //if (modifiers & Qt::MetaModifier)
    //if (modifiers & Qt::KeypadModifier)
    //if (modifiers & Qt::GroupSwitchModifier)
    return native;
}

quint32 QxtGlobalShortcutPrivate::nativeKeycode ( Qt::Key key )
{
    QxtX11Data x11;
    if ( !x11.isValid() )
        return 0;

    KeySym keysym = XStringToKeysym ( QKeySequence ( key ).toString().toLatin1().data() );
    if ( keysym == NoSymbol )
        keysym = static_cast<ushort> ( key );

    return XKeysymToKeycode ( x11.display(), keysym );
}

bool QxtGlobalShortcutPrivate::registerShortcut ( quint32 nativeKey, quint32 nativeMods )
{
    QxtX11Data x11;
    return x11.isValid() && x11.grabKey ( nativeKey, nativeMods, x11.rootWindow() );
}

bool QxtGlobalShortcutPrivate::unregisterShortcut ( quint32 nativeKey, quint32 nativeMods )
{
    QxtX11Data x11;
    return x11.isValid() && x11.ungrabKey ( nativeKey, nativeMods, x11.rootWindow() );
}
